/*->c.vtmenu */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <ctype.h>
#include <time.h>

#include "h.os"
#include "h.wimp"


#include "h.wos"
#include "h.main"
#include "h.key"
#include "h.mym"
#include "h.pr"
#include "h.def"
#include "h.trans"

#include "h.term"


#include "h.vtlo"
#include "h.vtdef"
#include "h.vtkey"
#include "h.vtscr"
#include "h.vtcol"
#include "h.vtfile"
#include "h.vtwimp"
#include "h.vtselect"
#include "h.vtprint"
#include "h.vtchar"


#include "h.vtmenu"



/***************************************************************************/
/*
 Code to handle VT terminal menus
*/
/***************************************************************************/

#ifdef NEVER

void dynamvtset(int m4)
{
 int i;
 int target;

 if(m4==6) for(i=0;i<4;i++) tickst(vtgn_menu,i,i==vtgl);
 else
 if(m4==7) for(i=0;i<4;i++) tickst(vtgn_menu,i,i==vtgr);
 else
 if(m4>=-1 && m4<6)
 {
  if(m4==1) target=vtupss;
  else
  if(m4==0) target=vtncs;
  else      target=vtgn[m4-2];

  for(i=0;i<VTMAXSET;i++) tickst(vtcset_menu,i,i==target);
 }
}


static void decodecset(int m4,int m5)
{
 if(m5>=0 && m5<VTMAXSET)
  switch(m4)
  {
    case 0: /* ncs */
           vtncs=m5;
           break;

    case 1:
           vtupss=m5;
           break;

    case 2:
    case 3:
    case 4:
    case 5:
           vtgn[m4-2]=m5;
           break;

    case 6:
           if(m5<4) vtgl=m5;
           break;

    case 7:
           if(m5<4) vtgr=m5;
           break;

   default:
           return;
  }

  dynamvtset(m4);
}

#endif


static int tempvtncs;
static int tempvtupss;
static int tempvtgl;
static int tempvtgr;
static int tempvtgn[4];

char * vtsetnames[20]=
{
 "V00", /* ASCII */
 "V01", /* British */
 "V02", /* Dutch */
 "V03", /* Finnish */
 "V04", /* French */
 "V05", /* French/Canadian */
 "V06", /* German */
 "V07", /* Italian */
 "V08", /* Norwegian/Danish */
 "V09", /* Portuguese */
 "V10", /* Spanish */
 "V11", /* Swedish */
 "V12", /* Swiss */
 "V13", /* Latin-1 */
 "V14", /* Spec. Graphics */
 "V15", /* Supp. Graphics */
 "V16", /* Technical */
 "V17", /* Alt ROM */
 "V18", /* Alt Graphics */
 "V19", /* DRCS */
};


void vtwritesetname(int icon,int val)
{
 writeicon(whandle[VTSET],icon,transtoken(vtsetnames[val]));
}



int vtsetwindow(void)
{
 int i;
 int handle=createwindow(VTSET);

 tempvtncs=vtncs;
 tempvtupss=vtupss;
 tempvtgl=vtgl;
 tempvtgr=vtgr;
 for(i=0;i<4;i++) tempvtgn[i]=vtgn[i];

 vtwritesetname(10,vtncs);
 vtwritesetname(13,vtupss);
 for(i=0;i<4;i++) vtwritesetname(16+i*3,vtgn[i]);
 writeiconf(handle,28,"G%d",vtgl);
 writeiconf(handle,31,"G%d",vtgr);

 return(handle);
}



static void vtdec(int * var)
{
 if(buttons==0x4 && (*var)>0)  *var=*var-1;
 else
 if(buttons==0x1 && (*var)<19) *var=*var+1;
 else                          return;

 vtwritesetname(icon+2,*var);
}


static void vtinc(int * var)
{
 if(buttons==0x1 && (*var)>0)  *var=*var-1;
 else
 if(buttons==0x4 && (*var)<19) *var=*var+1;
 else                          return;

 vtwritesetname(icon+1,*var);
}



static void vtgdec(int * var)
{
 if(buttons==0x4 && (*var)>0)  *var=*var-1;
 else
 if(buttons==0x1 && (*var)<3)  *var=*var+1;
 else                          return;

 writeiconf(ewindow,icon+2,"G%d",*var);
}


static void vtginc(int * var)
{
 if(buttons==0x1 && (*var)>0)  *var=*var-1;
 else
 if(buttons==0x4 && (*var)<3)  *var=*var+1;
 else                          return;

 writeiconf(ewindow,icon+1,"G%d",*var);
}



void vtseticon(void)
{
 int i;

 switch(icon)
 {
  case  8:
          vtdec(&tempvtncs);
          break;
  case 11:
          vtdec(&tempvtupss);
          break;
  case 14:
  case 17:
  case 20:
  case 23:
          vtdec(&tempvtgn[(icon-14)/3]);
          break;

  case  9:
          vtinc(&tempvtncs);
          break;

  case 12:
          vtinc(&tempvtupss);
          break;

  case 15:
  case 18:
  case 21:
  case 24:
          vtinc(&tempvtgn[(icon-15)/3]);
          break;

  case 26:
          vtgdec(&tempvtgl);
          break;

  case 29:
          vtgdec(&tempvtgr);
          break;

  case 27:
          vtginc(&tempvtgl);
          break;

  case 30:
          vtginc(&tempvtgr);
          break;

  case 32:
          vtncs=tempvtncs;
          vtupss=tempvtupss;
          vtgl=tempvtgl;
          vtgr=tempvtgr;
          for(i=0;i<4;i++) vtgn[i]=tempvtgn[i];
          if(buttons==0x4) zapmenu();
          break;
 }
}


/*****************************************************************************/


void togval(int * var)
{
 (* var)^=1;
}

void tickval(int var,int item,int * mhandle)
{
 if(var) tick(mhandle,item); 
 else    untick(mhandle,item);
}


#ifdef NEVER


void setpopdisplay(void)
{
 int i;

 tickst(vtcurs_menu,0,!vtcurs);
 tickst(vtcurs_menu,1,vtcurs && !vtblock);
 tickst(vtcurs_menu,2,vtcurs && vtblock);

 tickval(screenmode,0,vtdisp_menu);
 tickval(smooth,1,vtdisp_menu);
 tickval(width>80,2,vtdisp_menu);
 tickval(insertmode,3,vtdisp_menu);
 tickval(wrapmode,4,vtdisp_menu);
 tickval(destbkspc,6,vtdisp_menu);


 for(i=0;i<=VTSTTABS;i++) tickst(vtstatus_menu,i,vtstatus==i);
}




void decodecurs(int m4)
{
 vtrefreshcursor();

 switch(m4)
 {
  case 0: /* none */
         vtcurs=0;
         break;

  case 1: /* line */
         vtcurs=1;
         vtblock=0;
         break;

  case 2: /* block */
         vtcurs=1;
         vtblock=1;
         break;

  default:
          return;
 }

 vtrefreshcursor();
}



void  decodedisplay(int m3,int m4,int m5)
{
 switch(m3)
 {
  case 0:
         screenm(screenmode^1);
         break;

  case 1:
         togval(&smooth);
         break;

  case 2:
         if(width>80) go80();
         else         go132();
         break;

  case 3:
         togval(&insertmode);
         break;

  case 4:
         togval(&wrapmode);
         break;

  case 5:
         decodecurs(m4);
         break;

  case 6:
         togval(&destbkspc);
         break;

  case 7:
         /* character sets ... */
       /*  decodecset(m4,m5); */
         break;

 case  8:
         /* status line ... */
         if(m4>=0 && m4<=3) vtsetstatusline(m4);
         break;

 case  9: /* zoom */
         break;

 }
 m5=m5;
}

#endif


static int tempvtcurs;
static int tempwidth;
static int tempscreenmode;
static int tempsmooth;
static int tempinsertmode;
static int tempwrapmode;
static int tempdestbkspc;
static int tempstatusline;

/*
static char * cursornames[3]={"None","Line","Block"};
static char * statusnames[4]={"None","Local","Host","Tabs"};
*/


static char * cursornames[3]={"V20","V21","V22"};
static char * statusnames[4]={"V23","V24","V25","V26"};


void vtdisplayicon(void)
{
 int handle=whandle[TDISPLAYVT];

 switch(icon)
 {
  case 0:
         selectst(handle,0,tempscreenmode^=1);
         break;

  case 1:
         selectst(handle,1,tempsmooth^=1);
         break;

  case 2:
         selectst(handle,2,(tempwidth=(80+132)-tempwidth)>80);
         break;

  case 3:
         selectst(handle,3,tempinsertmode^=1);
         break;

  case 4:
         selectst(handle,4,tempwrapmode^=1);
         break;

  case 5:
         selectst(handle,5,tempdestbkspc^=1);
         break;

  case 7:
  case 9:
         if(buttons==0x1) icon=(7+9)-icon;

         if(icon==7 && tempvtcurs) tempvtcurs--;
         else
         if(icon==9 && tempvtcurs<2) tempvtcurs++;
         else                        return;

         writeicon(handle,8,transtoken(cursornames[tempvtcurs]));
         break;

 case 11:
 case 13:
         if(buttons==0x1) icon=(11+13)-icon;

         if(icon==11 && tempstatusline)   tempstatusline--;
         else
         if(icon==13 && tempstatusline<3) tempstatusline++;
         else                             return;

         writeicon(handle,12,transtoken(statusnames[tempstatusline]));
         break;



  case 14:
          if(tempwidth!=width)
          {
           if(tempwidth>80) go132();
           else             go80();
          }

          if(tempscreenmode!=screenmode) screenm(tempscreenmode);

          smooth=tempsmooth;
          insertmode=tempinsertmode;
          wrapmode=tempwrapmode;
          destbkspc=tempdestbkspc;

          vtrefreshcursor();
          if(tempvtcurs==0)
          {
           vtcurs=vtblock=0;
          }
          else
          if(tempvtcurs==1)
          {
           vtcurs=1;
           vtblock=0;
          }
          else
          {
           vtcurs=vtblock=1;
          }
          vtrefreshcursor();

          vtsetstatusline(tempstatusline);

          if(buttons==0x4) zapmenu();
          break;
 }
}


int setupvtdisplay(void)
{
 int handle=createwindow(TDISPLAYVT);

 if(!vtcurs) tempvtcurs=0;
 else        tempvtcurs=1+vtblock;

 tempwidth=width;
 tempscreenmode=screenmode;
 tempsmooth=smooth;
 tempinsertmode=insertmode;
 tempwrapmode=wrapmode;
 tempdestbkspc=destbkspc;

 tempstatusline=vtstatus;
 
 selectst(handle,0,tempscreenmode);
 selectst(handle,1,tempsmooth);
 selectst(handle,2,tempwidth>80);
 selectst(handle,3,tempinsertmode);
 selectst(handle,4,tempwrapmode);
 selectst(handle,5,tempdestbkspc);

 writeicon(handle, 8,transtoken(cursornames[tempvtcurs]));
 writeicon(handle,12,transtoken(statusnames[tempstatusline]));

 return(handle);
}




#ifdef NEVER


void setpopkeyboard(void)
{
 tickval(newlinemode,0,vtkey_menu);
 tickval(automode,1,vtkey_menu);
 tickval(keylockmode,2,vtkey_menu);
 tickval(cursorkeymode,3,vtkey_menu);
 if(ansimode) tickval(keypadmode,4,vtkey_menu);
 else         tickval(altkey,4,vtkey_menu);
 tickval(vtswopbs,5,vtkey_menu);
}



void  decodekeyboard(int m3,int m4)
{
 m4=0;
 switch(m3)
 {
  case 0:
         togval(&newlinemode);
         break;

  case 1:
         togval(&automode);
         keyboardoncaret(1);
         break;

  case 2:
         togval(&keylockmode);
         break;

  case 3:
         togval(&cursorkeymode);
         break;

  case 4:
         if(ansimode) togval(&keypadmode);
         else         togval(&altkey);
         break;

  case 5: /* swop DEL and BS */
         vtswopbs^=1;
         break;

  case 6:
         macrosshow();
         break;

 }
}


#endif



static int tempnewlinemode;
static int tempautomode;
static int tempkeylockmode;
static int tempcursorkeymode;
static int tempaltkey;
static int tempvtswopbs;


void vtkeyicon(void)
{
 int handle=whandle[TKEYVT];

 switch(icon)
 {
  case 0:
         selectst(handle,0,tempnewlinemode^=1);
         break;

  case 1:
         selectst(handle,1,tempautomode^=1);
         break;

  case 2:
         selectst(handle,2,tempkeylockmode^=1);
         break;

  case 3:
         selectst(handle,3,tempcursorkeymode^=1);
         break;

  case 4:
         selectst(handle,4,tempaltkey^=1);
         break;

  case 5:
         selectst(handle,5,tempvtswopbs^=1);
         break;

  case 6:
         newlinemode=tempnewlinemode;
         automode=tempautomode;
         keylockmode=tempkeylockmode;
         cursorkeymode=!tempcursorkeymode;

         if(ansimode) keypadmode=tempaltkey;
         else         altkey=tempaltkey;

         vtswopbs=tempvtswopbs;

         keyboardoncaret(1);
         if(buttons==0x4) zapmenu();
         break;
 }
}


int setupvtkey(void)
{
 int handle=createwindow(TKEYVT);

 tempnewlinemode=newlinemode;
 tempautomode=automode;
 tempkeylockmode=keylockmode;
 tempcursorkeymode=!cursorkeymode;

 if(ansimode) tempaltkey=keypadmode;
 else         tempaltkey=altkey;

 tempvtswopbs=vtswopbs;

 selectst(handle,0,tempnewlinemode);
 selectst(handle,1,tempautomode);
 selectst(handle,2,tempkeylockmode);
 selectst(handle,3,tempcursorkeymode);
 selectst(handle,4,tempaltkey);
 selectst(handle,5,tempvtswopbs);

 return(handle);
}




#ifdef NEVER

void setpoplinemode(void)
{
 tickval(localmode,0,vtlmode_menu);
 tickval(terminalmode==TMODEVT,1,vtlmode_menu);
 tickval(echomode,2,vtlmode_menu);
 tickval(txcrlnf,3,vtlmode_menu);
 tickval(rxcrlnf,4,vtlmode_menu);
 tickval(concode==2,5,vtlmode_menu);
 tickval(concode==1,6,vtlmode_menu);
 tickval(bit8c,7,vtlmode_menu);
}

void decodelinemode(int m3,int m4)
{
 m4=0;

 switch(m3)
 {
  case 0:
         togval(&localmode);
         break;

  case 1:
         if(terminalmode==TMODEVT) terminalmode=TMODENUL;
         else                      terminalmode=TMODEVT;
         terminalmodeset=terminalmode;
         break;

  case 2:
         togval(&echomode);
         break;

  case 3:
         togval(&txcrlnf);
         break;

  case 4:
         togval(&rxcrlnf);
         break;

  case 5:
         if(concode==TERMIGNRCTRLS) concode=TERMEXECCTRLS;
         else                       concode=TERMIGNRCTRLS;
         break;

  case 6:
         if(concode==TERMDISPCTRLS) concode=TERMEXECCTRLS;
         else                       concode=TERMDISPCTRLS;
         break;

  case 7:
         togval(&bit8c);
         break;
 }

}

#endif



static int templocalmode;
static int temptmode;
static int tempechomode;
static int temptxcrlnf;
static int temprxcrlnf;
static int tempconcode;
static int tempbit8c;
       int linemodeswitch;


void vtlinemodeicon(void)
{
 int handle=whandle[TLINEMODE];

 switch(icon)
 {
  case 0:
         selectst(handle,0,templocalmode^=1);
         break;

  case 1:
         if(temptmode==TMODEVT) temptmode=TMODENUL;
         else                   temptmode=TMODEVT;
         selectst(handle,1,temptmode==TMODEVT);
         break;

  case 2:
         selectst(handle,2,tempechomode^=1);
         break;

  case 3:
         selectst(handle,3,tempbit8c^=1);
         break;

  case 4:
         selectst(handle,4,temptxcrlnf^=1);
         break;

  case 5:
         selectst(handle,5,temprxcrlnf^=1);
         break;

  case 6:
         if(tempconcode==TERMIGNRCTRLS) tempconcode=TERMEXECCTRLS;
         else                           tempconcode=TERMIGNRCTRLS;

         selectst(handle,6,
                    tempconcode==TERMDISPCTRLS || tempconcode==TERMEXECCTRLS);
         selectst(handle,7,tempconcode==TERMDISPCTRLS);
         shadeiconst(handle,7,tempconcode==TERMIGNRCTRLS);
         break;

  case 7:
         if(tempconcode==TERMDISPCTRLS) tempconcode=TERMEXECCTRLS;
         else                           tempconcode=TERMDISPCTRLS;

         selectst(handle,6,
                   tempconcode==TERMDISPCTRLS || tempconcode==TERMEXECCTRLS);
         selectst(handle,7,tempconcode==TERMDISPCTRLS);
         shadeiconst(handle,7,tempconcode==TERMIGNRCTRLS);
         break;

  case 8:
         localmode=templocalmode;

         terminalmode=temptmode;
         terminalmodeset=terminalmode;

         echomode=tempechomode;
         txcrlnf=temptxcrlnf;
         rxcrlnf=temprxcrlnf;
         concode=tempconcode;


         bit8c=tempbit8c;

         if(buttons==0x4) zapmenu();
         break;
 }
}


int setupvtlinemode(void)
{
 int handle=createwindow(TLINEMODE);

 linemodeswitch=1;

 templocalmode=localmode;
 temptmode=terminalmode;
 tempechomode=echomode;
 temptxcrlnf=txcrlnf;
 temprxcrlnf=rxcrlnf;
 tempconcode=concode;
 tempbit8c=bit8c;

 selectst(handle,0,templocalmode);
 selectst(handle,1,temptmode==TMODEVT);
 selectst(handle,2,tempechomode);
 selectst(handle,3,tempbit8c);
 selectst(handle,4,temptxcrlnf);
 selectst(handle,5,temprxcrlnf);

 selectst(handle,6,tempconcode==TERMDISPCTRLS || tempconcode==TERMEXECCTRLS);
 selectst(handle,7,tempconcode==TERMDISPCTRLS);
 shadeiconst(handle,7,tempconcode==TERMIGNRCTRLS);

 return(handle);
}


void linemodeicon(void)
{
 if(linemodeswitch) vtlinemodeicon();
 else               vxlinemodeicon();
}



static int tempvtlock;
static int tempvtbeep;
static int tempcedup;


void miscvticon(void)
{
 int handle=whandle[TMISCVT];
 int newsize;

 switch(icon)
 {
  case 5:
         selectst(handle,5,tempvtlock^=1);
         break;
 
  case 4:
         selectst(handle,4,tempvtbeep^=1);
         break;

  case 6:
         selectst(handle,6,tempcedup^=1);
         break;

  case 7:
         vtlock=tempvtlock;
         vtbeep=tempvtbeep;
         if(cedup!=tempcedup) toggleced(); 
         if(geticonint(handle,3,&newsize)) vtuserbuffsize(newsize);
         strcpy(vtanswerback,iconaddr(handle,1));
         if(buttons==0x4) zapmenu();
         break;
 }
}



              /* N L R D U */

static char miscentryiclst[2][5]=
{
          1,          0,           0,           3,            0,
          3,          0,           0,           0,            1,
};



void vtmisckey(int * key)
{
 int cicon;
 int j;
 int ch;

 ch=*key;

 switch(ch)
 {
       case 27:
               zapmenu();
               break;

       case CR:
               ch=CDOWN;

    case 0x18E:
    case 0x18F:
    case 0x19C:
    case 0x19D:
    case 0x19E:
    case 0x19F:
               ch&=0x18F;
               for(j=0;j<2;j++) if(miscentryiclst[j][0]==icon) break;
               cicon=miscentryiclst[j][(ch-0x18B)];
               if(cicon) iecarrot(whandle[TMISCVT],cicon);
               break;

    default:return;
 }
 *key=-1;
}





int setupmiscvt(void)
{
 int handle=createwindow(TMISCVT);

 tempvtlock=vtlock;
 tempvtbeep=vtbeep;
 tempcedup=cedup;

 writeicon(handle,1,vtanswerback);
 writeiconf(handle,3,"%d",buffsize);

 selectst(handle,5,tempvtlock);
 selectst(handle,4,tempvtbeep);
 selectst(handle,6,tempcedup);

 return(handle);
}



#ifdef NEVER

void setpopgeneral(void)
{
 tickst(vtgen_menu,3,vtbeep);
 tickst(vtgen_menu,5,cedup);
 tickst(vtgen_menu,6,vtlock);
 writemenuf(vtbuffsize_menu,0,"%d",buffsize);
 setpoplinemode();
}



void decodegeneral(int m2,int m3,int m4)
{
 int newsize;

 switch(m2)
 {
  case 0:  /* line mode */
         decodelinemode(m3,m4);
         break;

  case 1:  /* answer back */
         break;

  case 2:
         vtreset();
         break;

  case 3:
         vtbeep^=1;
         break;

  case 4:          /* buffer size */
         if(getmenuint(vtbuffsize_menu,0,&newsize)) vtuserbuffsize(newsize);
         break;

  case 5:
         toggleced();
         break;

  case 6:
         vtlock^=1;
         break;
 }

 m3=m4;
}

#endif



static void setpopsetup(void)
{
/* tickst(vtsetup_menu,8,cedup); */
}


static void decodesetup(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 6:
         macrosshow();
         break;

  case 7:
         vtreset();
         break;

/*  case 8:
         toggleced();
         break; */
 }

 m3=m4;
}





void setpopvtfile(void)
{
 unshadest(vtfile_menu,2,spfp==NULL);
 unshadest(vtfile_menu,3,spfp!=NULL);
 unshadest(vtfile_menu,4,spfp!=NULL);
 tickst(vtfile_menu,3,spoolflag);
 tickst(vtfile_menu,5,spconcode);
 tickst(vtfile_menu,6,vtinvert);
}



void decodevtfile(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 0:         /* save buffer */
         break;

  case 1:         /* save screen */
         break;

  case 2:         /* open spool */
         break;

  case 3:
         spooltoggle();
         break;

  case 4:
         spoolclose();
         break;

  case 5:
         spoolcont();
         break;

  case 6:
         vtinvert^=1;
         break;
 }

 m2=m3=m4=0;
}




void setpopvtselect(void)
{
 unshadest(vtselec_menu,0,vtselect);
 unshadest(vtselec_menu,1,vtselect);
 unshadest(vtselec_menu,2,vtselect);
 unshadest(vtselec_menu,3,vtselect);
 unshadest(vtselec_menu,4,vtselect && spfp);
 unshadest(vtselec_menu,5,vtselect);
 unshadest(vtselec_menu,6,(int)vtpastebuff && !vtselect);
}



void decodevtselect(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 0:   /* save */

         break;

  case 1:   /* print */
         printzone();
         break;

  case 2:  /* clear */
         vtremzone();
         break;

  case 3:  /* send */
         sendzone(0);
         break;

  case 4:  /* spool */
         spoolzone();
         break;

  case 5: /* copy */
         sendzone(1);
         break;

  case 6: /* paste */
         vtpastezone();
         break;
 }

 m3=m4=0;
}






void setpopvtprinter(void)
{
 tickval(autoprint,2,vtprint_menu);
 tickval(conoprint,3,vtprint_menu);
 tickval(printer,4,vtprint_menu);
 tickval(printff,5,vtprint_menu);
 tickval(printarea,6,vtprint_menu);
}


static void decodevtprinter(int m2,int m3,int m4)
{
 switch(m2)
 {
  case 0:
         printbuffer();
         break;

  case 1:
         printscreen();
         break;

  case 2:
         setprintlo(&autoprint,!autoprint);
         break;

  case 3:
         setprintlo(&conoprint,!conoprint);
         break;

  case 4:
         togval(&printer);
         break;

  case 5:
         togval(&printff);
         break;

  case 6:
         togval(&printarea);
         break;
 }
 m3=m4;
}



void setpopvtterm(void)
{
 setpopvtfile();
 setpopvtselect();
 setpopvtprinter();
 setpopsetup();
}



void decodevtterm(int m1,int m2,int m3,int m4,int m5)
{
 switch(m1)
 {
  case 0:
         decodevtfile(m2,m3,m4);
         break;

  case 1:
         decodevtselect(m2,m3,m4);
         break;

  case 2:
         decodevtprinter(m2,m3,m4);
         break;

  case 3:
         decodesetup(m2,m3,m4);
         break;

 }
 m5=0;
}

